const userModel = require('../models/user');
const userProfileModel = require('../models/user_profile');
const { generateToken } = require('../utils/auth');
const axios = require('axios');
require('dotenv').config();

// 模拟用户数据 - 当抖音API或数据库不可用时使用
const mockUsers = {
  // 默认的测试用户
  'test_openid': {
    id: 1,
    openid: 'test_openid',
    unionid: 'test_unionid',
    nickname: '测试用户',
    avatar: 'https://example.com/avatar.jpg'
  }
};

// 抖音小程序登录 - 符合抖音官方小程序登录规范
exports.login = async (req, res) => {
  try {
    const { code, userInfo } = req.body;
    
    if (!code) {
      return res.status(400).json({ success: false, message: '缺少code参数' });
    }
    
    try {
      // 尝试正常登录流程
      // 调用抖音开放平台API，用code换取openid和session_key
      // 确保code是字符串类型
      const codeStr = String(code);
      console.log('尝试调用抖音API换取openid和session_key:', {
        appid: process.env.APPID,
        code: codeStr.substring(0, 10) + '...'
      });
      
      const response = await axios.get('https://developer.toutiao.com/api/apps/jscode2session', {
        params: {
          appid: process.env.APPID,
          secret: process.env.APP_SECRET,
          code: codeStr
        }
      });
      
      console.log('抖音API返回数据:', response.data);
      
      if (!response.data.openid || response.data.errcode) {
        // 如果openid为空、有错误码或者返回了bad secret错误，使用模拟数据
        console.warn('抖音API返回无效数据或错误，切换到模拟数据模式:', response.data);
        throw new Error(`抖音API错误: ${response.data.errmsg || 'OpenID is empty'}, use mock data`);
      }
      
      const { openid, session_key, unionid } = response.data;
      
      // 查找或创建用户
      let user = await userModel.findUserByOpenid(openid);
      
      if (!user) {
        // 创建新用户 - 包含抖音官方文档中提到的openid和unionid
        const userData = {
          openid,
          unionid: unionid || '', // 可选，用于同一主体下多小程序用户识别
          nickname: userInfo?.nickName || '',
          avatar: userInfo?.avatarUrl || ''
        };
        user = await userModel.createUser(userData);
        console.log('创建新用户:', user);
        
        // 存储完整用户数据到user_profiles表
        if (userInfo) {
          try {
            await userProfileModel.createOrUpdateUserProfile({
              user_id: user.id,
              openid: openid,
              unionid: unionid || '',
              nickName: userInfo.nickName,
              avatarUrl: userInfo.avatarUrl,
              gender: userInfo.gender || null,
              language: userInfo.language || null,
              city: userInfo.city || null,
              province: userInfo.province || null,
              country: userInfo.country || null,
              raw_data: userInfo ? JSON.stringify(userInfo) : null
            });
            console.log('完整用户数据已存储到user_profiles表');
          } catch (profileError) {
            console.error('存储用户完整数据失败:', profileError);
            // 即使存储失败，也继续登录流程
          }
        }
      } else if (userInfo) {
        // 更新用户信息
        const userData = {
          nickname: userInfo.nickName,
          avatar: userInfo.avatarUrl,
          unionid: unionid || user.unionid // 更新unionid（如果有）
        };
        user = await userModel.updateUser(openid, userData);
        console.log('更新用户信息:', user);
        
        // 更新完整用户数据到user_profiles表
        try {
          await userProfileModel.createOrUpdateUserProfile({
            user_id: user.id,
            openid: openid,
            unionid: unionid || user.unionid,
            nickName: userInfo.nickName,
            avatarUrl: userInfo.avatarUrl,
            gender: userInfo.gender || null,
            language: userInfo.language || null,
            city: userInfo.city || null,
            province: userInfo.province || null,
            country: userInfo.country || null,
            raw_data: JSON.stringify(userInfo)
          });
          console.log('完整用户数据已更新到user_profiles表');
        } catch (profileError) {
          console.error('更新用户完整数据失败:', profileError);
          // 即使更新失败，也继续登录流程
        }
      }
      
      // 生成token - 基于用户ID的JWT认证
      const token = generateToken(user.id);
      
      // 返回符合抖音小程序规范的用户信息
      res.json({
        success: true,
        token,
        data: {
          token,
          userInfo: {
            id: user.id,
            openid: user.openid,
            nickName: user.nickname,
            avatarUrl: user.avatar
          }
        },
        message: '登录成功'
      });
    } catch (error) {
      console.warn('抖音登录API或数据库操作失败，使用模拟数据:', error.message);
      
      // 检查是否是开发环境
      const isDevelopment = process.env.NODE_ENV === 'development' || process.env.NODE_ENV === undefined;
      
      if (isDevelopment) {
        // 在开发环境下使用模拟数据 - 确保与前端接口格式一致
        const mockOpenid = 'test_openid';
        let mockUser = mockUsers[mockOpenid];
        
        // 如果有用户信息，更新模拟用户
        if (userInfo) {
          mockUser = {
            ...mockUser,
            nickname: userInfo.nickName || mockUser.nickname,
            avatar: userInfo.avatarUrl || mockUser.avatar
          };
        }
        
        // 生成token
        const token = generateToken(mockUser.id);
        
        // 返回模拟数据，保持与正式环境相同的格式
        res.json({
          success: true,
          token,
          data: {
            token,
            userInfo: {
              id: mockUser.id,
              openid: mockUser.openid,
              nickName: mockUser.nickname,
              avatarUrl: mockUser.avatar
            }
          },
          message: '登录成功（模拟数据，仅用于开发环境）'
        });
      } else {
        // 生产环境下，返回友好的错误信息
        res.status(500).json({
          success: false,
          message: '登录失败，请稍后重试',
          error: error.message
        });
      }
    }
  } catch (error) {
    console.error('登录失败:', error);
    res.status(500).json({
      success: false,
      message: '登录失败，请稍后重试',
      error: error.message
    });
  }
};

// 获取用户信息 - 返回user_profiles表中的完整用户数据
exports.getUserInfo = async (req, res) => {
  try {
    const { userId } = req.user;
    
    try {
      // 尝试从数据库获取用户信息
      const user = await userModel.findUserById(userId);
      
      if (!user) {
        // 如果数据库中没有找到用户，尝试使用模拟数据
        throw new Error('User not found in database');
      }
      
      // 同时从user_profiles表获取完整用户信息
      let userProfile = null;
      try {
        userProfile = await userProfileModel.getUserProfileByUserId(userId);
        console.log('从user_profiles表获取的完整用户信息:', userProfile);
      } catch (profileError) {
        console.error('获取user_profiles表数据失败:', profileError);
        // 如果获取失败，继续使用users表的数据
      }
      
      // 优先使用user_profiles表的数据，如果没有则使用users表的数据
      const userInfoToReturn = {
        id: user.id,
        openid: user.openid,
        unionid: user.unionid,
        nickName: userProfile?.nickName || user.nickname,
        avatarUrl: userProfile?.avatarUrl || user.avatar,
        // 包含user_profiles表中的其他字段
        gender: userProfile?.gender || null,
        language: userProfile?.language || null,
        city: userProfile?.city || null,
        province: userProfile?.province || null,
        country: userProfile?.country || null
      };
      
      // 返回完整的用户信息
      res.json({
        success: true,
        data: {
          userInfo: userInfoToReturn
        },
        message: '获取用户信息成功'
      });
    } catch (dbError) {
      console.warn('数据库获取用户信息失败，使用模拟数据:', dbError.message);
      
      // 检查是否是开发环境
      const isDevelopment = process.env.NODE_ENV === 'development' || process.env.NODE_ENV === undefined;
      
      if (isDevelopment) {
        // 在开发环境下使用模拟数据
        // 找到与用户ID匹配的模拟用户
        let mockUser = null;
        for (const key in mockUsers) {
          if (mockUsers[key].id === userId) {
            mockUser = mockUsers[key];
            break;
          }
        }
        
        // 如果没有找到匹配的模拟用户，使用默认的测试用户
        if (!mockUser) {
          mockUser = mockUsers['test_openid'];
        }
        
        // 返回与登录接口一致的模拟数据格式
        res.json({
          success: true,
          data: {
            userInfo: {
              id: mockUser.id,
              openid: mockUser.openid,
              unionid: mockUser.unionid,
              nickname: mockUser.nickname,
              avatar: mockUser.avatar
            }
          },
          message: '获取用户信息成功（模拟数据，仅用于开发环境）'
        });
      } else {
        // 生产环境下，返回友好的错误信息
        res.status(404).json({
          success: false,
          message: '用户不存在',
          error: dbError.message
        });
      }
    }
  } catch (error) {
    console.error('获取用户信息失败:', error);
    res.status(500).json({
      success: false,
      message: '获取用户信息失败，请稍后重试',
      error: error.message
    });
  }
};